﻿// 0917train03.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <algorithm>
#include <limits>
#include <iomanip>
#include <unordered_map>
#include <unordered_set>

using namespace std;

/*
指定时间前, 找到满足条件的点
核酸检测点的距离, 每个点当前的人数

出发时间是10分钟的倍数, 最晚结束时间
题目中给出的距离是整数，单位是公里，时间1分钟为一基本单位

限制：
每公里距离花费时间10分钟，费用是10元
每检测一个人的时间 1分钟
每个核酸点工作时间 8点到20点
结果可立刻知道

在张三去某个核酸点的路上花费的时间内，人数动态变化, 变化规则是
在非核酸检测时间内，没有人排队
8点-10点每分钟增加3人
12点-14点每分钟增加10人
要求将所有满足条件的核酸检测点按照优选规则排序列出：优选规则：
花费时间最少的核酸检测点排在前面。
花费时间一样，花费费用最少的核酸检测点排在前面。
时间和费用一样，则ID值最小的排在前面

输入描述
H1 M1
H2 M2
N
ID1 D1 C1
ID2 D2 C2
...
IDn Dn Cn

H1：当前时间Q的小时数。M1：当前时间的分钟数，
H2：指定完成核算时间的小时数。M2：指定完成核算时间的分钟数。
N：所有核酸检测点个数。
ID1：核酸点的ID值。D1：核酸检测点距离张三的距离。C1：核酸检测点当前检测的人数。

输出描述：
N
满足要求的核酸检测点个数
I2:选择后的核酸检测点IDT2:做完核酸花费的总时间(分钟)M2:去该核算点花费的费用

示例一
输入
10 30
14 50
3
1 10 19
2 8 20
3 21 3
输出：
2
2 80 80
1 190 100
 */

/*
2 8 20 标号 公里 人数
1 190 100 100 90人
每公里距离花费时间10分钟，费用是10元
每检测一个人的时间花费是1分钟
每个核酸点工作时间 8点到20点
结果可立刻知道

在非核酸检测时间内，没有人排队
8点-10点每分钟增加3人
12点-14点每分钟增加10人

花费时间最少的核酸检测点排在前面。
花费时间一样，花费费用最少的核酸检测点排在前面。
时间和费用一样，则ID值最小的排在前面
 */
class Solution01
{
public:
    struct Node
    {
        int id, cost_time, money;
        Node() = default;
        Node(int id, int cost_time, int money) :id(id),
    		cost_time(cost_time), money(money)
    	{};

        bool operator<(const Node&other) const
        {
	        if (cost_time ==other.cost_time)
	        {
		        if (money ==other.money)
		        {
                    return id < other.id;
		        }
                return money < other.money;
	        }
            return cost_time < other.cost_time;
        }
    };

    int getGrow(int start, int arrive_cost_time, int init_count)
    {
        /*
        8点-10点每分钟增加3人
        12点-14点每分钟增加10人
        */
        vector<int>interval_a = { 8 * 60, 10 * 60 };
        vector<int>interval_b = { 12 * 60, 14 * 60 };

        int count = init_count;
        for (int t=0; t< arrive_cost_time; t++)
        {
	        if (start >=interval_a[0] && start <interval_a[1])
	        {
                count += 3;
	        }
            if (start >=interval_b[0] && start <interval_b[1])
            {
                count += 10;
            }
            if (count>0) count--;
            start++;
        }

        return count;
        //getGrow
    }

    vector<Node>getSortV(vector<vector<int>>& choose_v)
    {
/*
每公里距离花费时间10分钟，费用是10元
每检测一个人的时间花费是1分钟
每个核酸点工作时间 8点到20点
 */
        vector<Node>sort_vec;
        for (auto&item:choose_v)
        {
            int id = item[0];
            int distance = item[1];
            //原本人数
            int people_init = item[2];
            //开销 每公里 10元
            int money = distance * 10;

            //时间 每公里 10分钟
            int arrive_cost_time = distance * 10;
            int total_time = arrive_cost_time;

            int arrive_time = start_time + arrive_cost_time;

            if (arrive_time<pos_start || arrive_time>pos_end)
            {
                //超过营业时间,无效
                continue;
            }
            //超过最晚结束时间,无效
            if (arrive_time > end_time) continue;

            int people_cost_time = getGrow(start_time, arrive_cost_time, people_init);

        	total_time += people_cost_time;

            //做完时间超过最晚时间,无效
            arrive_time += people_cost_time;
            if (arrive_time > end_time) continue;

            //int id, cost_time, money;
            Node node (id, total_time, money);
            sort_vec.push_back(node);
	        //for
        }
        return sort_vec;
        //getSortV
    }

    Solution01(vector<vector<int>>&time_v, vector<vector<int>>&choose_v)
    {
        //计算1每个点花费的时间,2每个点花费的钱,3每个点出结果的时间
        //ID 距离 当前检测人数
        //choose_v
        if (time_v.size() == 2)
        {
            if (time_v[0].size()==2)
            {
                start_time = time_v[0][0] * 60 + time_v[0][1];
            }
            if (time_v[1].size()==2)
            {
                end_time = time_v[1][0] * 60 + time_v[1][1];
            }
        }

        vector<Node>sort_v = getSortV(choose_v);

        sort(sort_v.begin(), sort_v.end());

        /*
         满足要求的核酸检测点个数
		I2:选择后的核酸检测点IDT2:做完核酸花费的总时间(分钟)M2:去该核算点花费的费用
         */
        cout << sort_v.size() << endl;

        for (auto&node:sort_v)
        {
            cout << node.id << ' ';
            cout << node.cost_time << ' ';
            cout << node.money << endl;
        }

        //Solution01
    }
private:
    int start_time = 0, end_time = 0;
    int pos_start = 8 * 60, pos_end = 20 * 60;
};

int main()
{
/*
10 30
14 50
3
1 10 19
2 8 20
3 21 3
*/
    string start_time, end_time;
    getline(cin, start_time);
    getline(cin, end_time);

    stringstream start_sstream(start_time);
    string token;
    vector<vector<int>>time_v(2);
    while (start_sstream>>token)
    {
        time_v[0].push_back(stoi(token));
    }

    stringstream end_sstream(end_time);
    while (end_sstream>>token)
    {
        time_v[1].push_back(stoi(token));
    }

    int v_size;
    cin >> v_size;
    cin.ignore();
    vector<vector<int>>choose_vec;
    for (int i=0; i<v_size; i++)
    {
        vector<int>item;
        string item_str;
        getline(cin, item_str);
        stringstream item_sstream(item_str);
        while (item_sstream>>token)
        {
            item.push_back(stoi(token));
        }
        choose_vec.push_back(item);
    }


	Solution01 solu(time_v, choose_vec);

}

// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单

// 入门使用技巧: 
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件
